package com.zhentao.controller;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.zhentao.dto.FriendsRequestDto;
import com.zhentao.dto.HandlerFriendsRequestsDto;
import com.zhentao.pojo.User;
import com.zhentao.pojo.UserFriend;
import com.zhentao.service.UserFriendService;
import com.zhentao.service.UserService;
import com.zhentao.vo.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.*;

@RestController
public class MessageController {


    // 注入添加好友service
    @Autowired
    private UserFriendService userFriendsService;

    @Autowired
    private UserService userService;





//    // 模拟登录,测试
//    @PostMapping("/user/login")
//    public Result<Object> login(@RequestBody User user, HttpSession httpSession) {
//        if (user == null || !"123456".equals(user.getPassword())) {
//            return Result.fail("用户名或密码错误");
//        }
//
//        httpSession.setAttribute("currentUser", user.getUsername());
//        return Result.success();
//    }
//
//    /**
//     * 获取用户名
//     *
//     * @param httpSession HttpSession
//     * @return String
//     */
//    @GetMapping("/getUsername")
//    public Result<String> getUsername(HttpSession httpSession) {
//        return Result.success((String) httpSession.getAttribute("currentUser"));
//    }



    //3.4 消息模块
    //3.41 好友管理
    //好友添加:通过搜索用户邮箱发送好友申请
    //好友验证:对方同意后建立好友关系
    //好友列表:显示好友头像、昵称、在线状态

//    !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!好友模块----开始!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!好

    // 添加好友 Todo
    @PostMapping("/friends/request")
    public Result<Object> addFriend(@RequestBody FriendsRequestDto friendsRequestDto) {
        // 添加好友申请
        UserFriend userFriend = new UserFriend();
        userFriend.setUserId(Long.valueOf(friendsRequestDto.getFromUserId()));
        userFriend.setFriendUserId(Long.valueOf(friendsRequestDto.getToUserId()));
        // 转台标记给等待验证
        userFriend.setFriendStatus(1);
        userFriend.setCreateTime(new Date());
        boolean save = userFriendsService.save(userFriend);
        if (save){
            return Result.success();
        }
        return Result.fail("好友添加失败,检擦控制台");

    }


    // 获取好友列表
    @GetMapping("/friends")
    public Result<Object> friendsList(@RequestParam Integer userId) {
        if (userId == null){
            return Result.fail("请输入用户ID");
        }
        
        // 获取当前用户的所有好友关系（双向查询）
        // 1. 当前用户主动添加的好友（user_id = userId）
        List<UserFriend> userInitiatedFriends = userFriendsService.list(
                new QueryWrapper<UserFriend>()
                        .eq("user_id", userId)
                        .eq("friend_status", 2)
        );
        
        // 2. 别人向当前用户发起并被同意的好友申请（friend_user_id = userId）
        List<UserFriend> receivedFriends = userFriendsService.list(
                new QueryWrapper<UserFriend>()
                        .eq("friend_user_id", userId)
                        .eq("friend_status", 2)
        );
        
        // 收集所有好友的用户ID，避免重复
        Set<Long> friendUserIds = new HashSet<>();
        
        // 添加当前用户主动添加的好友
        for (UserFriend friend : userInitiatedFriends) {
            friendUserIds.add(friend.getFriendUserId());
        }
        
        // 添加别人向当前用户发起的好友申请
        for (UserFriend friend : receivedFriends) {
            friendUserIds.add(friend.getUserId());
        }
        
        // 根据用户ID查询用户信息
        List<User> friendsUser = new ArrayList<>();
        for (Long friendUserId : friendUserIds) {
            User user = userService.getOne(new QueryWrapper<User>().eq("id", friendUserId));
            if (user != null) {
                friendsUser.add(user);
            }
        }
        
        return Result.success(friendsUser);
    }


    // 获取待验证的好友数量
    @GetMapping("/friends/requests/count")
    public Result<Object> friendsRequestsCount(@RequestParam Integer userId) {
        if (userId == null){
            return Result.fail("请输入用户ID");
        }
        // 获取当前用户收到的待通过好友申请数量
        List<UserFriend> receivedPendingRequests = userFriendsService.list(
            new QueryWrapper<UserFriend>()
                .eq("friend_user_id", userId)
                .eq("friend_status", 1)
        );
        return Result.success(receivedPendingRequests.size());
    }

    // 好友搜索
    @GetMapping("/friends/search")
    public Result<Object> searchFriend(@RequestParam(required = false) String keyword, @RequestParam(required = false) Integer currentUserId) {
        // 账号正常才可以搜索
        if (keyword == null){
            return Result.fail("请输入搜索关键字");
        }
        if (currentUserId == null) {
            currentUserId = 1; // 默认用户ID
        }
        
        System.out.println("搜索关键字：" + keyword);
        List<User> users = new ArrayList<>();
        
        // 判断是否是手机号
        if (keyword.matches("^1[3-9]\\d{8}$")) {
            // 根据手机号查询
            User user = userService.getOne(new QueryWrapper<User>().eq("phone", keyword).eq("status",1));
            if (user != null) {
                users.add(user);
            }
        }
        if (keyword.matches("^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$")) {
            // 根据邮箱查询
            User user = userService.getOne(new QueryWrapper<User>().eq("email", keyword).eq("status",1));
            if (user != null) {
                users.add(user);
            }
        }

        // 既不是手机号也不是邮箱，根据用户昵称搜索
        User user = userService.getOne(new QueryWrapper<User>().like("nickname", keyword).eq("status",1));
        if (user != null){
            users.add(user);
        }

        if (users.isEmpty()){
            return Result.fail("未找到该用户");
        }
        
        // 为每个用户添加好友关系状态
        List<User> usersWithFriendStatus = new ArrayList<>();
        for (User searchUser : users) {
            // 排除自己
            if (searchUser.getId().equals(Long.valueOf(currentUserId))) {
                continue;
            }
            
            // 查询与当前用户的好友关系状态
            UserFriend friendRelation = userFriendsService.getOne(
                new QueryWrapper<UserFriend>()
                    .eq("user_id", currentUserId)
                    .eq("friend_user_id", searchUser.getId())
            );
            
            // 设置好友关系状态
            if (friendRelation != null) {
                if (friendRelation.getFriendStatus() == 2) {
                    // 已是好友
                    searchUser.setIsFriend(true);
                    searchUser.setFriendStatus(2);
                } else if (friendRelation.getFriendStatus() == 1) {
                    // 已发送申请，等待对方同意
                    searchUser.setRequestSent(true);
                    searchUser.setFriendStatus(1);
                } else if (friendRelation.getFriendStatus() == 3) {
                    // 被拒绝，可以再次发起申请
                    searchUser.setCanResend(true);
                    searchUser.setFriendStatus(3);
                }
            } else {
                // 没有好友关系，可以添加
                searchUser.setCanAdd(true);
                searchUser.setFriendStatus(0);
            }
            
            usersWithFriendStatus.add(searchUser);
        }
        
        return Result.success(usersWithFriendStatus);
    }


    // 好友申请
    @GetMapping("/friends/requests")
    public Result<Object> friendsRequests(@RequestParam Integer userId,@RequestParam String type) {
        if (userId == null){
            return Result.fail("请输入用户ID");
        }
        if (type == null){
            return Result.fail("请输入申请类型");
        }
        
        List<UserFriend> friends = new ArrayList<>();
        if ("received".equals(type)){
            // 收到的好友申请 - 查询所有状态
            friends = userFriendsService.list(new QueryWrapper<UserFriend>().eq("friend_user_id", userId));
            // 为每个好友申请设置发起方的用户信息
            for (UserFriend friend : friends) {
                User user = userService.getOne(new QueryWrapper<User>().eq("id", friend.getUserId()));
                friend.setFriendUserInfo(user);
            }
        }
        else if ("sent".equals(type)){
            // 发送的好友申请 - 查询所有状态
            friends = userFriendsService.list(new QueryWrapper<UserFriend>().eq("user_id", userId));
            // 为每个好友申请设置接收方的用户信息
            for (UserFriend friend : friends) {
                User user = userService.getOne(new QueryWrapper<User>().eq("id", friend.getFriendUserId()));
                friend.setFriendUserInfo(user);
            }
        }
        
        return Result.success(friends);
    }


    // 处理好友申请
    // 单条同意/拒绝
    @PutMapping("/friends/requests")
    public Result<Object> handleFriendsRequests(@RequestBody HandlerFriendsRequestsDto dto) {
        if (dto.getFriendId() == null) {
            return Result.fail("请提供好友申请ID");
        }
        if (dto.getAction() == null) {
            return Result.fail("请提供操作类型");
        }
        
        try {
            // 根据friendId查询好友申请记录
            UserFriend userFriend = userFriendsService.getById(dto.getFriendId());
            if (userFriend == null) {
                return Result.fail("好友申请不存在");
            }
            
            // 根据action更新状态
            if ("accept".equals(dto.getAction())) {
                userFriend.setFriendStatus(2); // 已通过
            } else if ("reject".equals(dto.getAction())) {
                userFriend.setFriendStatus(3); // 被拒绝
            } else {
                return Result.fail("无效的操作类型");
            }
            
            userFriend.setUpdateTime(new Date());
            boolean updated = userFriendsService.updateById(userFriend);
            
            if (updated) {
                return Result.success("操作成功");
            } else {
                return Result.fail("操作失败");
            }
        } catch (Exception e) {
            return Result.fail("处理好友申请时发生错误: " + e.getMessage());
        }
    }

    // 批量处理好友申请
    @PutMapping("/friends/requests/batch")
    public Result<Object> handleFriendsRequestsBatch(@RequestBody HandlerFriendsRequestsDto dto) {
        if (dto.getRequestIds() == null || dto.getRequestIds().isEmpty()) {
            return Result.fail("请提供好友申请ID列表");
        }
        if (dto.getAction() == null) {
            return Result.fail("请提供操作类型");
        }
        
        try {
            // 批量查询好友申请记录
            List<UserFriend> userFriends = userFriendsService.listByIds(dto.getRequestIds());
            if (userFriends.isEmpty()) {
                return Result.fail("没有找到相关的好友申请");
            }
            
            // 批量更新状态
            for (UserFriend userFriend : userFriends) {
                if ("accept".equals(dto.getAction())) {
                    userFriend.setFriendStatus(2); // 已通过
                } else if ("reject".equals(dto.getAction())) {
                    userFriend.setFriendStatus(3); // 被拒绝
                } else {
                    return Result.fail("无效的操作类型");
                }
                userFriend.setUpdateTime(new Date());
            }
            
            boolean updated = userFriendsService.updateBatchById(userFriends);
            
            if (updated) {
                return Result.success("批量操作成功，共处理 " + userFriends.size() + " 条申请");
            } else {
                return Result.fail("批量操作失败");
            }
        } catch (Exception e) {
            return Result.fail("批量处理好友申请时发生错误: " + e.getMessage());
        }
    }

    // 删除好友
    @DeleteMapping("/friends/{friendId}")
    public Result<Object> deleteFriend(@PathVariable Long friendId, @RequestParam Integer currentUserId, @RequestParam(required = false) Boolean deleteMessages) {
        if (friendId == null) {
            return Result.fail("请提供好友ID");
        }
        if (currentUserId == null) {
            return Result.fail("请提供当前用户ID");
        }

        try {
            // 删除双向好友关系
            // 1. 删除当前用户 -> 好友的关系（当前用户是发起方）
            QueryWrapper<UserFriend> queryWrapper1 = new QueryWrapper<>();
            queryWrapper1.eq("user_id", currentUserId)
                        .eq("friend_user_id", friendId)
                        .eq("friend_status", 2); // 只删除已成为好友的关系

            // 2. 删除好友 -> 当前用户的关系（好友是发起方）
            QueryWrapper<UserFriend> queryWrapper2 = new QueryWrapper<>();
            queryWrapper2.eq("user_id", friendId)
                        .eq("friend_user_id", currentUserId)
                        .eq("friend_status", 2); // 只删除已成为好友的关系

            // 执行删除操作
            boolean deleted1 = userFriendsService.remove(queryWrapper1);
            boolean deleted2 = userFriendsService.remove(queryWrapper2);

            if (deleted1 || deleted2) {
                // TODO: 如果deleteMessages为true，还需要删除相关的聊天记录
                if (Boolean.TRUE.equals(deleteMessages)) {
                    // 这里可以添加删除聊天记录的逻辑
                    // chatMessageService.deleteMessagesBetweenUsers(currentUserId, friendId);
                }

                return Result.success("好友删除成功");
            } else {
                return Result.fail("好友关系不存在或删除失败");
            }
        } catch (Exception e) {
            return Result.fail("删除好友时发生错误: " + e.getMessage());
        }
    }

    //3.4.2 群聊功能
    //群聊创建:选中多个好友发起群聊
    //群信息展示:前 4 名成员头像、群名称、成员数量
    //群聊管理:群主可修改群公告、群名称
    //3.43 会话管理
    //会话列表:显示私聊 /群聊的最后一条消息、时间戳
    //消息类型:支持文字、语音、表情、图片、文件、视频
    //聊天设置:备注、置顶、消息免打扰、聊天记录搜索
    //投诉功能:支持填写原因、上传图片，提交平台审核
}
